# -*- coding: latin-1 -*-
from django.db import models
from django.db.models import Q, Sum
from datetime import *
from django.contrib.auth.models import *
from decimal import Decimal
from dateutil.relativedelta import *

from tjango.extra_admin.models import *
from tjango.apps.formapago.models import *
from tjango.apps.contactos.models import Contacto

class Cuota(models.Model):
	'''No se graba en la base. Solo se usa para mostrar cómo serían las cuotas'''
	
	nro = models.IntegerField()
	importe = models.DecimalField(decimal_places = 2, max_digits=10)
	vto = models.DateField()

	class Meta:
		managed=False

class Cuenta_corriente (ExtraModel):
	''' Corresponde a un plan de cuotas mensuales (eventualmente una), de un deudor a un acreedor
	con posibilidad de introducir un intermediario, el cual deberá rendir al acreedor todo lo que cobre al deudor'''
	
	deudor = models.ForeignKey(Contacto, related_name="deudas")
	intermediario = models.ForeignKey(Contacto, null=True, blank=True, related_name="intermedios")
	acreedor = models.ForeignKey(Contacto, related_name="creditos")
		
	importe = models.DecimalField(decimal_places=2, max_digits=10)

	cantidad_cuotas = models.IntegerField(default=1)
	primer_nro = models.IntegerField(default=1)
	primer_importe = models.DecimalField(decimal_places=2, max_digits=10)
	primer_vto = models.DateField(blank=True,null=True)
	
	incobrable = models.BooleanField()

	def default_primer_importe(self):
		return self.importe / self.cantidad_cuotas
		
	def cuotas(self):
		ctas = []
		for i in range(self.primer_nro,self.cantidad_cuotas+self.primer_nro-1):
			c = Cuota(nro=i)
			if i == self.primer_nro:
				c.importe = self.primer_importe
			else:
				c.importe = (self.importe - self.primer_importe) / (self.cantidad_cuotas-1)
			if self.primer_vto:
				c.vto = self.primer_vto+relativedelta(months=+i-1)
			else:
				c.vto = None
			ctas.append(c)
		return ctas

	def saldo(self, para=None, hasta=None):
		if para == None or para==self.deudor:
			if self.incobrable:
				return 0.0
			if hasta:
				importe = sum([c.importe for c in self.cuotas() if c.vto <= hasta])
			else:
				importe = self.importe
			if self.pagado():
				return importe - self.pagado()
			else:
				return importe
		else:
			return self.pagado(a = self.intermediario) - self.pagado(por=self.intermediario)		
		
	def pagado(self, por=None, a=None):
		if por ==None:
			por = self.deudor
		pagos = self.pagos.filter(pago__paga = por, pago__fecha__isnull=False)
		if a<> None:
			pagos  = pagos.filter(pago__cobra = a)
		return sum([v.importe for v in pagos])

	def estado(self):
		if self.incobrable:
			return "Incobrable"
		elif not self.primer_vto:
			return "Presupuesto"
		elif self.pagado()==0:
			return "Adeuda"
		elif self.saldo()==0:
			return "Saldada"
		else:
			return "Cobrado una parte"
		
	def __unicode__(self):
		s  = ""
		if self.comprobante:
			s = s + self.comprobante + " - "
		if self.deudor_id:	
			s = s + "%s " % self.deudor.__unicode__()
		if self.primer_vto:
			s = s + "(%s)" % self.primer_vto
		return s

	class Meta:
		ordering = ['deudor__apellido', 'deudor__nombre', '-primer_vto']
		

class Pago(ExtraModel):
	''' Corresponde a un recibo por el pago de un monto de dinero. Puede corresponder a varias
	cuotas de diversas cuentas corrientes'''
	
	fecha = models.DateField()
	comprobante = models.CharField(max_length=20, blank=True, null=True)

	paga = models.ForeignKey(Contacto, blank=True,null=True,related_name="pagos")
	cobra = models.ForeignKey(Contacto, blank=True,null=True,related_name="cobros_")

	forma_pago = models.OneToOneField(FormaDePago, blank=True,null=True, related_name="recibo_pago")
	forma_cobro = models.OneToOneField(FormaDePago, blank=True,null=True, related_name="recibo_cobro")

	def calc_cuotas(self):
		return [Pago_de_cuota(cobro=self, cuenta=c, importe=c.saldo()) for c in self.paga.cuentas_impagas()]

	def __init__(self, *args, **kwargs):
		super(Cobro, self).__init__(*args, **kwargs)
		forma_pago = FormaPago(es_ingreso=False)
		forma_cobro = FormaPago(es_ingreso=True)

	def suma_importes(self):
		return sum_inline(self.cuotas,"importe")
		
	def __unicode__(self):
		return str(self.id)

	class Meta:
		ordering = ["-fecha"]

class Pago_de_cuota(models.Model):
	''' Especifica que cuota/s de que cuenta se está pagando. Si no se especifica la cuota, 
	se utiliza la primera con saldo'''
	
	pago= models.ForeignKey(Pago, related_name='cuotas') 
	cuenta = models.ForeignKey(Cuenta_corriente, related_name='pagos')
	importe = models.DecimalField(decimal_places=2, max_digits=10)
	cuotas = models.CommaSeparatedIntegerField(max_length=20, blank=True,null=True)
	
	def get_cuotas(self):
		res = []
		suma = 0
		pagado = self.cuenta.pagos.filter(pago__fecha__lt=self.pago.fecha).sum('importe')
		for c in self.cuenta.cuotas():
			suma += c.importe
			if suma >= pagado and suma <= pagado + self.importe:
				res.append(c)
		return ','.join(res)

	def calc_importe(self):
		if self.pago.fecha:
			return self.cuenta.saldo(para=self.pago.paga, hasta=pago.fecha)
		else:
			return self.cuenta.saldo(para=self.pago.paga)

	def __unicode__(self):
		s = u"%s por $%s" % (self.cuenta, self.importe)
		return s
		
	class Meta:
		ordering = ["-pago__fecha"]

